API Reference

Copy of ModelEC

Deepcopy of ModelEC

Function zero to represent the empty ModelEC

_jump_to_dict

Function to turn a JuMP model to a dictionary

_print_summary(io::IO, model::AbstractEC)

Print a plain-text summary of model to io.

Function to verify the data loaded from the disk

Function to verify the users data loaded from the disk

Function to create the output dataframe of the economics of the EC

Function to create the output dataframe of peak power for the EC

General fallback for branching priorities

Function to create the dataframe to report the status of the optimization

General fallback for notations

Function to create the output dataframe of design capacity

Function to create the output dataframe of the users' economics

Function to create the output dataframe of peak power

Function to get the list of the assets for a user

Function to get the list of the assets for a user in a list of elements

Function to get the list of the assets for a user

Function to get the list of the assets for a user in a list of elements except a list of given types

Function to get the asset type of a component

buildbaseutility!(ECModel::AbstractEC, base_group::AbstractGroupANC)

When in the CO case the ANC model is used as base case, then this function builds the corresponding constraint

buildbaseutility!(ECModel::AbstractEC, base_group::AbstractGroupNC)

When in the CO case the NC model is used as base case, then this function builds the corresponding constraint

buildbaseutility!(ECModel::AbstractEC, noaggregatorgroup::AbstractGroupANC)

When in the CO case the ANC model is used as reference case for when the aggregator is not in the group, then this function builds the corresponding constraint

buildleastprofitable!(ECModel::AbstractEC; noaggregatorgroup::AbstractGroup=GroupNC(), add_EC=true)

Function to build the model to identify the least profitable coalition

Build the mathematical problem for the EC

Abstract build function model for generic EnergyCommunity model

buildnoaggutility!(ECModel::AbstractEC, noaggregatorgroup::AbstractGroupANC; basemodel=nothing)

When in the CO case the ANC model is used as reference case for when the aggregator is not in the group, then this function builds the corresponding constraint

buildnoaggutility!(ECModel::AbstractEC, noaggregator_group::AbstractGroupNC; kwargs...)

When the NC case is the reference value when no aggregator is available, then no changes in the model are required

buildnoaggutility!(ECModel::AbstractEC, noaggregator_group::Any)

Not implemented case

buildnoaggleastprofitable(ECModel::ModelEC; usenotations=false, optimizer=nothing)

Function to create an ecmodel that returns the least profitable coalition for ANC models

Set the ANC-specific model for the EC

Set the CO-specific model for the EC

Set the NC/ANC-specific model for the EC

business_plan(ECModel::AbstractEC, profit_distribution)

Function to describe the cost term distributions by all users for all years.

Parameters

• ECModel : AbstractEC EnergyCommunity model
• profit_distribution Final objective function
• usersetfinancial User set to be considered for the financial analysis

Returns

The output value is a NamedTuple with the following elements
- df_business
    Dataframe with the business plan information

business_plan_plot(ECModel::AbstractEC, profit_distribution)

Function to describe the cost term distributions by all users for all years.

Parameters

• ECModel : AbstractEC EnergyCommunity model
• df_business Dataframe with the business plan information
• plot_struct Plot structure of the business plan

Returns

The output value is a plot with the business plan information

calculate_energy_ratios(users_data, _P_ren_us, user_agg_set, agg_id, time_set, _P_tot_us, _x_us)

Calculate energy ratios '''

Outputs

• PV_frac
• PVfractot
• wind_frac
• windfractot

'''

calculate_grid_export(ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the energy community and users. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_export(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the Aggregated Non Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_export(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_export(::AbstractGroupNC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the Non-Cooperative case Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_import(ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the energy community and users. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_import(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the Aggregated Non Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_import(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_import(::AbstractGroupNC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the Non-Cooperative case Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

calculate_grid_ratios_noagg(users_data, user_agg_set, agg_id, time_set, _P_tot_us_agg)

Calculate energy ratios '''

Outputs

• gridfracagg
• gridfractot_agg

'''

calculate_grid_ratios_noagg(users_data, user_agg_set, agg_id, time_set, _P_tot_us_noagg)

Calculate energy ratios '''

Outputs

• gridfracnoagg
• gridfractot_noagg

'''

calculate_production(ECModel::AbstractEC)

Function to calculate the energy production by user Outputs –––- productionusEC : DenseAxisArray DenseAxisArray representing the production by the EC and each user

calculate_production_shares(ECModel::AbstractEC; per_unit::Bool=true)

Calculate energy ratio by energy production resource for a generic group Output is normalized with respect to the demand when per_unit is true '''

Outputs

frac : DenseAxisArray DenseAxisArray describing the share of energy production by energy resource by user and the entire system, normalized with respect to the demand of the corresponding group

'''

calculate_self_consumption(ECModel::AbstractEC; per_unit::Bool=true)

Calculate the demand that each user meets using its own sources, or self consumption. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

calculate_self_production(ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the self production for each user. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

calculate_shared_consumption(ECModel::AbstractEC; per_unit::Bool=true)

Calculate the demand that each user meets using its own sources or other users. When onlyshared is false, also self consumption is considered, otherwise only shared consumption. Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

calculate_shared_consumption(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the demand that each user meets using its own sources or other users for the Aggregated Non Cooperative case. In this case, there can be shared energy, non only self consumption. When onlyshared is false, also self consumption is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

calculate_shared_consumption(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the demand that each user meets using its own sources or other users for the Cooperative case. In the Cooperative case, there can be shared energy, non only self consumption. When onlyshared is false, also self consumption is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

calculate_shared_consumption(::AbstractGroupNC, ECModel::AbstractEC; kwargs...)

Calculate the demand that each user meets using its own sources or other users for the Non-Cooperative case. In the Non-Cooperative case, there is no shared energy, only self consumption. Shared energy means energy that is shared between Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

calculate_shared_energy_abs_agg(users_data, user_set, time_set,
    _P_ren_us, _P_tot_us, shared_en_frac, shared_cons_frac)

Calculate the absolute shared produced energy (en), the shared consumption (cons) and self consumption (self cons) '''

Outputs

• sharedenfracusagg
• sharedentotfracagg
• sharedconsfracusagg
• sharedconstotfracagg
• selfconsfracusagg
• selfconstotfracagg

'''

calculate_shared_energy(users_data, user_agg_set, agg_id, time_set,
    _P_ren_us, _P_tot_us, shared_en_frac, shared_cons_frac)

Calculate the shared produced energy (en) and the shared consumption (cons) ratios '''

Outputs

• sharedenfracusagg
• sharedentotfracagg
• sharedconsfracusagg
• sharedconstotfracagg

'''

calculate_shared_production(ECModel::AbstractEC; per_unit::Bool=true)

Calculate the energy that each user produces and uses in its own POD or it is commercially consumed within the EC, when creaded. When onlyshared is false, also self production is considered, otherwise only shared energy. Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

calculate_shared_production(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the shared produced energy for the Aggregated Non Cooperative case. In this case, there can be shared energy between users, not only self production. When onlyshared is false, also self production is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

calculate_shared_production(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production. When onlyshared is false, also self production is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

calculate_shared_production(::AbstractGroupNC, ECModel::AbstractEC; kwargs...)

Calculate the shared produced energy for the Non-Cooperative case. In the Non-Cooperative case, there is no shared energy between users, only self production. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

calculate_time_shared_consumption(ECModel::AbstractEC)

Calculate the time series of the shared consumed energy for the Energy Community.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

calculate_time_shared_consumption(::AbstractGroupANC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared consumed energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

calculate_time_shared_consumption(::AbstractGroupCO, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared consumed energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

calculate_time_shared_consumption(::AbstractGroupNC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared consumed energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

calculate_time_shared_production(ECModel::AbstractEC; kwargs...)

Calculate the time series of the shared consumed energy for the Energy Community.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

calculate_time_shared_production(::AbstractGroupANC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

calculate_time_shared_production(::AbstractGroupCO, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

calculate_time_shared_production(::AbstractGroupNC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

Check whether the dictionary data has the needed components

Function to get the components value of a dictionary

Function to get the components list of a dictionary

create_example_data(parent_folder, config_name::String = "default")

Create an example data for the Energy Community model. This function creates in the specified folder the necessary data to run the Energy Community model, based on the specified configuration name.

Parameters

• parent_folder : AbstractString Parent folder where the example data will be created
• config_name : String Configuration name to be used to create the example data Supported values: "default"

Function to create output data after the optimization for TheoryOfGames.jl

plot_sankey(ECModel::AbstractEC)

Function to create the input data for plotting any Sankey diagram representing the energy flows across the energy community

Inputs

ECModel : AbstractEC Energy Community model name_units : (optional) Vector Labels used for the sankey diagram with the following order: "Market buy", [users labels], "Community", "Market sell", [users labels]

Function to get the list of devices for a user

Return main data elements of the dataset of the ECModel: general parameters, users data and market data

Return main data elements of the dataset: general parameters, users data and market data

Function get field that throws an error if the field is not found

Function to get the components value of a dictionary, with default value

Function to get the components value of a dictionary

Function to safely get a field of a dictionary with default value

finalize_results!(::AbstractGroupANC, ECModel::AbstractEC)

Function to finalize the results of the Aggregated Non Cooperative model after the execution

finalize_results!(::AbstractGroupCO, ECModel::AbstractEC)

Function to finalize the results of the Cooperative model after the execution Nothing to do

finalize_results!(::AbstractGroupNC, ECModel::AbstractEC)

Function to finalize the results of the Non Cooperative model after the execution Many of the variables are set to zero due to the absence of cooperation between users

Function to get the general parameters

Function to get the list of generators for a user

Get annotations for Benders decomposition

Get the EC group type

Get variables related to the user u_name for a DenseAxisArray

Get variables related to the user u_name for a SparseAxisArray

Get the EC user set

Function to check whether an user has any asset

Function to check whether an user has an asset type

Function to check whether an user has an asset given its name

Function to know if a dictionary has a particular component

Auxiliary function to check if the key 'type' is available in the dictionary d, otherwise false

load!(output_file::AbstractString, ECModel::AbstractEC)

Function to save the results and the model to the hard drive

Function to get the market configuration

name(model::AbstractEC)

Return the name of the model.

name(model::ModelEC)

Return the name of the model.

Function to return the objective function by User

Function to return the objective function by user in the Aggregated Non Cooperative case

Function to return the objective function by user in the NonCooperative case

Function to return the objective function by user in the NonCooperative case

Output results for the EC configuration

Output results for the NC configuration

Function to throw error for unformatted data

Function to parse a string value of a profile to load the corresponding dataframe

Function to parse a personalized processing to generate the data When profile_value is a dictionary, then the user is asking a custom processing of data by a function

Function to parse a string value of a profile to load the corresponding dataframe

Function to parse a string value of a profile to load the corresponding dataframe

Function to parse the peak power categories and tariff

plot_sankey(ECModel::AbstractEC, sank_data::Dict)

Function to plot the Sankey diagram representing the energy flows across the energy community. This function can be used to plot the sankey diagram of already processed data sank_data.

Inputs

ECModel : AbstractEC Energy Community model name_units : (optional) Vector Labels used for the sankey diagram with the following order: "Market buy", [users labels], "Community", "Market sell", [users labels]

plot_sankey(ECModel::AbstractEC)

Function to plot the Sankey diagram representing the energy flows across the energy community

Inputs

ECModel : AbstractEC Energy Community model name_units : (optional) Vector Labels used for the sankey diagram with the following order: "Market buy", [users labels], "Community", "Market sell", [users labels]

prepare_summary(::AbstractGroupANC, ECModel::AbstractEC;
    user_set::Vector=Vector())

Save base excel file with a summary of the results for the Aggregated Non Cooperative case

prepare_summary(::AbstractGroupCO, ECModel::AbstractEC;
    user_set::Vector=Vector())

Save base excel file with a summary of the results for the Cooperative case

prepare_summary(::AbstractGroupNC, ECModel::AbstractEC, file_summary_path::AbstractString;
    user_set::Vector=Vector())

Prepare the dataframe lists to be saved in an excel file

Outputs

output_list: Vector{Pair{String, DataFrame}} Vector of pairs representing the sheets of the Excel file and the corresponding data to save

Function to print a summary of the results of the model. The function dispatches the execution to the appropriate function depending on the Aggregation type of the EC

print_summary(::AbstractGroupANC, ECModel::AbstractEC)

Function to print the main results of the model

print_summary(::AbstractGroupCO, ECModel::AbstractEC)

Function to print the main results of the model

print_summary(::AbstractGroupNC, ECModel::AbstractEC)

Function to print the main results of the model

Function to get a specific profile

Function to get a specific profile

Function to get the profile dictionary

Function to read the input of the optimization model described as a yaml file

Set the EC user set equal to the stored user_set

Function to save a summary of the results of the model. The function dispatches the execution to the appropriate function depending on the Aggregation type of the EC

Set the EC group type

setleastprofitableprofit!(ECModel::AbstractEC, profitdistribution)

Function to set the profit distribution of the least profitable problem

Parameters

ECModel : ModelEC Model of the community profit_distribution : AbstractDict Profit distribution per user

Function to set the objective function of the model of the Aggregated-Non-Cooperative model

Set the objective for the cooperative approach

Function to set the objective function of the model of the Non-Cooperative model

Set the EC user set

split_financial_terms(ECModel::AbstractEC, profit_distribution)

Function to describe the cost term distributions by all users.

Parameters

• ECModel : AbstractEC EnergyCommunity model
• profit_distribution Final objective function

Returns

The output value is a NamedTuple with the following elements
- NPV: the NPV of each user given the final profit_distribution adjustment
by game theory techniques
- CAPEX: the annualized CAPEX
- OPEX: the annualized operating costs (yearly maintenance and yearly peak and energy grid charges)
- REP: the annualized replacement costs
- RV: the annualized recovery charges
- REWARD: the annualized reward distribution by user
- PEAK: the annualized peak costs
- EN_SELL: the annualized revenues from energy sales
- EN_BUY: the annualized costs from energy consumption and buying
- EN_NET: the annualized net energy costs

splityearlyfinancialterms(ECModel::AbstractEC, profitdistribution)

Function to describe the cost term distributions by all users for all years.

Parameters

• ECModel : AbstractEC EnergyCommunity model
• profit_distribution Final objective function
• usersetfinancial User set to be considered for the financial analysis

Returns

The output value is a NamedTuple with the following elements
- NPV: the NPV of each user given the final profit_distribution adjustment by game theory techniques
- CAPEX: the annualized CAPEX
- OPEX: the annualized operating costs (yearly maintenance and yearly peak and energy grid charges)
- REP: the annualized replacement costs
- RV: the annualized recovery charges
- REWARD: the annualized reward distribution by user
- PEAK: the annualized peak costs
- EN_SELL: the annualized revenues from energy sales
- EN_BUY: the annualized costs from energy consumption and buying
- EN_NET: the annualized net energy costs

to_least_profitable_coalition_callback(ECModel::AbstractEC, base_group::AbstractGroup=GroupNC(); no_aggregator_group::AbstractGroup=GroupNC())

Function that returns a callback function that, given as input a profit distribution scheme, returns the coalition that has the least benefit in remaining in the grand coalition. The returned function leastprofitablecoalition_callback accepts an AbstractDict as argument that specifies the profit distribution by user that is used to compute the least benefit procedure.

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. basegroup : AbstractGroup (optional, default GroupNC()) Base group with respect the benefit is calculated. noaggregatorgroup : AbstractGroup (optional, default GroupNC()) Type of aggregation group of the community when no aggregator is available When not provided, an equivalent NonCooperative model is created and the corresponding utilities by user are used as reference case. numberofsolutions : (optional, default 1) Number of solutions to be returned at every iteration numberofsolutions <= 0: all solutions are returned numberofsolutions >= 1: specific number of solutions are returned relaxcombinatorial : (optional, default false) When true, the full least profitable coalition MILP problem is relaxed to continuous, in the combinatorial part directmodel : (optional, default false) When true the JuMP model is direct callbacksolution : Dict (optional, default empty) Dictionary of callbacks depending on the termination status of the optimization. Keys shall be of type JuMP.TerminationStatusCode, and outputs a function with as argument a ModelEC branchingpriorities : Bool (optional, default true) Option to specify if add the branching priorities decomposeANC : Bool (optional, default false) When True, if the noaggregatorgroup is ANC and, then the main optimization model is decomposed into two models: (a) when no Aggregator is in the coalition and (b) when the aggregator is in the coalition In this case, (a) is optimized first and if the optimization is beyond a given threshold, the execution is terminated without optimizing (b). The threshold is provided as an optional input in the callback function returned by the function. Otherwise the optimization continues with (b). decomposereltolerance : Float Relative tolerance of the decomposeANC procedure that compares the stopping criterion with the current result decomposeabstolerance : Float Absolute tolerance of the decomposeANC procedure that compares the stopping criterion with the current result

Return

leastprofitablecoalition_callback : Function Function that accepts as input an AbstractDict representing the benefit distribution by user

to_objective_callback_by_subgroup(ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for any model

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown.

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

to_objective_callback_by_subgroup(::AbstractGroupANC, ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for Aggregated Non Cooperative models

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. base_model : AbstractEC optional When provided, it represents the base model used to perform the calculations

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

to_objective_callback_by_subgroup(::AbstractGroupCO, ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for Aggregated Cooperative models

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. noaggregatorgroup : AbstractGroup (otional, default NonCooperative) EC group type when no aggregator is considered

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

to_objective_callback_by_subgroup(::AbstractGroupNC, ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for Non Cooperative models

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown.

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

to_utility_callback_by_subgroup(ECModel::AbstractEC, base_group_type::AbstractGroup)

Function that returns a callback function that quantifies the benefit of a given subgroup of users The returned function utility_func accepts as arguments an AbstractVector of users and returns the benefit with respect to the base case of the users optimized independently

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. basegrouptype : AbstractGroup Type of the base case to consider noaggregatorgroup : AbstractGroup (otional, default NonCooperative) EC group type for when no aggregator is considered

Return

utilitycallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

Get the list of users

Function to get the users configuration

load(output_file::AbstractString)

Function to save the results and the model to the hard drive

save(output_file::AbstractString, ECModel::AbstractEC)

Function to save the results and the model to the hard drive

objective_function(ECModel::AbstractEC)

Get the objective function of the model

Function to return the objective function by User

Solve the optimization problem for the EC

Solve the optimization problem for the EC

termination_status(ECModel::AbstractEC)

Calculate the optimization status of the model

Function to plot the EC model

Function to plot the results of the Aggregated non cooperative configuration

Function to plot the results of the Cooperative EC

plot(::AbstractGroupNC, ECModel::AbstractEC, output_plot_file::AbstractString;
    user_set::Vector=Vector(), line_width=2.0)

Function to plot the results of the user model

@enum ASSET_TYPE

Enumeration type to specify the type of the assets. Implemented values:

• LOAD: load components
• REN: renewable assets
• BATT: battery components
• CONV: battery converters
• THER: thermal generators

Structure encapsuling the data

Constructor of a ModelEC

Inputs

data : Dict Data of the EC grouptype : AbstractGroup Type of EC optimizer Optimizer of the model userset : Vector Vector of the users

Load Model from disk

file_name : str Filename

Copy constructor

EnumMode(ECModel::AbstractEC)

Function to create the EnumMode item for the TheoryOfGames.jl package

IterMode(ECModel::AbstractEC, base_group_type::AbstractGroup)

Function to create the IterMode item for the TheoryOfGames.jl package